﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using NUnit.Framework;
using Bastanteo.Persistencia;
using Bastanteo.Domain;
using Bastanteo.Persistencia.NH;

namespace Bastanteo.Tests
{
    [TestFixture]
    public class Test_RolDAO
    {
        // Variables a utilizar durante las pruebas
        private IRolDAO rolDAO = null; // Clase DAO que se va a probar
        private int codigoGenerado = 0; // Código de Local que se genera en Crear() y se utiliza para el resto de pruebas

        [TestFixtureSetUp]
        public void PrepararPruebas() // Se ejecuta 1 vez ANTES de los [Test]
        {
            // 1. Definimos la implementación del DAO a probar (ADO / NH / EF)
            rolDAO = new Persistencia.ADO.RolDAO();
            // 2. Eliminamos todas las salas en BD antes de eliminar los locales
            IUsuarioDAO usuarioDAO = new Persistencia.ADO.UsuarioDAO();
            foreach (Usuario usuario in usuarioDAO.Listar()) // Para cada registro en la tabla 'sala'...
                usuarioDAO.Eliminar(usuario); // Eliminar dicho registro
            // 3. Eliminamos todos los locales en BD antes de las pruebas
            foreach (Rol local in rolDAO.Listar()) // Para cada registro en la tabla 'local'...
                rolDAO.Eliminar(local);  // Eliminar dicho registro
            // 4. Creamos 2 locales de prueba para tenerlos disponibles en las pruebas
            rolDAO.Crear(new Rol() { RolDescripcion = "Administrador" });
            rolDAO.Crear(new Rol() { RolDescripcion = "Operador" });
        }

        [Test]
        public void Test1_Crear()
        {
            // 1. Clase a probar: LocalDAO
            Assert.IsNotNull(rolDAO);
            // 2. Declaramos e instanciamos la entidad de dominio
            Rol rolACrear = new Rol();
            rolACrear.RolDescripcion = "Prueba";
            // 3. Declaramos la entidad que contendrá el resultado
            Rol rolCreado = null;
            // 4. Probamos que no ocurra error al ejecutar el método
            Assert.DoesNotThrow(delegate
            {
                // 5. Ejecutamos el método a probar
                rolCreado = rolDAO.Crear(rolACrear);
                codigoGenerado = rolCreado.RolId;
            }, "local creado");
            // Probamos que la entidad resultante no sea nula
            Assert.IsNotNull(rolCreado);
            // Probamos que el código generado sea mayor a 0
            Assert.Greater(rolCreado.RolId, 0);
            // Probamos que el nombre registrado es igual al solicitado con la entidad
            Assert.AreEqual(rolCreado.RolDescripcion, rolACrear.RolDescripcion);
        }
        [Test]
        public void Test2_Obtener()
        {
            // 1. Clase a probar: LocalDAO
            Assert.IsNotNull(rolDAO);
            // 2. Definimos los datos para la prueba
            int codigo = codigoGenerado;
            // 3. Declaramos la entidad que contendrá el resultado
            Rol rolObtenido = null;
            // 4. Probamos que no ocurra error al ejecutar el método
            Assert.DoesNotThrow(delegate
            {
                // 5. Ejecutamos el método a probar
                rolObtenido = rolDAO.Obtener(codigo);
            });
            // Probamos que la entidad resultante no sea nula
            Assert.IsNotNull(rolObtenido);
            Assert.AreEqual(rolObtenido.RolId, codigo);
            Assert.IsNotNullOrEmpty(rolObtenido.RolDescripcion);
        }
        [Test]
        public void Test3_Modificar()
        {
            // 1. Clase a probar: LocalDAO
            Assert.IsNotNull(rolDAO);
            // 2. Declaramos e instanciamos la entidad de dominio
            Rol rolAModificar = rolDAO.Obtener(codigoGenerado);
            rolAModificar.RolDescripcion = "Prueba 2";
            // 3. Declaramos la entidad que contendrá el resultado
            Rol rolModificado = null;
            // 4. Probamos que no ocurra error al ejecutar el método
            Assert.DoesNotThrow(delegate
            {
                // 5. Ejecutamos el método a probar
                rolModificado = rolDAO.Modificar(rolAModificar);
            }, "Rol modificado");
            // Probamos que la entidad resultante no sea nula
            Assert.IsNotNull(rolModificado);
            // Probamos que el código generado sea mayor a 0
            Assert.AreEqual(rolModificado.RolId, codigoGenerado);
            // Probamos que el nombre registrado es igual al solicitado con la entidad
            Assert.AreEqual(rolModificado.RolDescripcion, rolAModificar.RolDescripcion);
        }
        [Test]
        public void Test4_Eliminar()
        {
            // 1. Clase a probar: LocalDAO
            Assert.IsNotNull(rolDAO);
            // 2. Definimos la entidad que contendrá el resultado
            Rol rolExistente = rolDAO.Obtener(codigoGenerado);
            // 3. Probamos que no ocurra error al ejecutar el método
            Assert.DoesNotThrow(delegate
            {
                // 5. Ejecutamos el método a probar
                rolDAO.Eliminar(rolExistente);
            });
            // Probamos que la entidad ya no existe
            Assert.IsNull(rolDAO.Obtener(codigoGenerado));
        }
        [Test]
        public void Test5_ListarTodos()
        {
            // 1. Clase a probar: LocalDAO
            Assert.IsNotNull(rolDAO);
            // 2. Declaramos la entidad que contendrá el resultado
            ICollection<Rol> rolesEncontrados = null;
            // 3. Probamos que no ocurra error al ejecutar el método
            Assert.DoesNotThrow(delegate
            {
                // 5. Ejecutamos el método a probar
                rolesEncontrados = rolDAO.Listar();
            }, "local eliminado");
            // Probamos que la entidad resultante no sea nula
            Assert.IsNotNull(rolesEncontrados);
            // Probamos que la cantidad de locales encontrados sea 2
            Assert.AreEqual(rolesEncontrados.Count, 2);
            // Probamos que cada local contenga la cadena de búsqueda en su nombre
            foreach (Rol rolEncontrado in rolesEncontrados)
            {
                Assert.IsNotNull(rolEncontrado);
                Assert.IsInstanceOf(typeof(Rol), rolEncontrado);
            }
        }
        [Test]
        public void Test6_ListarXNombre()
        {
            // 1. Clase a probar: LocalDAO
            Assert.IsNotNull(rolDAO);
            // 2. Definimos los datos para la prueba
            string busqueda = "Admin"; // Monterrico
            // 3. Declaramos la entidad que contendrá el resultado
            ICollection<Rol> rolesEncontrados = null;
            // 4. Probamos que no ocurra error al ejecutar el método
            Assert.DoesNotThrow(delegate
            {
                // 5. Ejecutamos el método a probar
                rolesEncontrados = rolDAO.ListarXNombre(busqueda);
            });
            // Probamos que la entidad resultante no sea nula
            Assert.IsNotNull(rolesEncontrados);
            // Probamos que la cantidad de locales encontrados sea 2
            Assert.AreEqual(rolesEncontrados.Count, 1);
            // Probamos que cada local contenga la cadena de búsqueda en su nombre
            foreach (Rol rolEncontrado in rolesEncontrados)
            {
                Assert.IsTrue(rolEncontrado.RolDescripcion.Contains(busqueda));
            }
        }
        [TestFixtureTearDown]
        public void TerminarPruebas()
        {
            NHibernateHelper.CerrarFabrica();
        }

    }
}